package leetcode.alg.demo;

/**
 * 输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。
 *
 * 示例 1：
 * 输入：arr = [3,2,1], k = 2
 * 输出：[1,2] 或者 [2,1]
 *
 * 示例 2：
 * 输入：arr = [0,1,2,1], k = 1
 * 输出：[0]
 *
 * 限制：
 * 0 <= k <= arr.length <= 10000
 * 0 <= arr[i] <= 10000
 *
 * 来源：力扣（LeetCode）
 * 链接：https://leetcode-cn.com/problems/zui-xiao-de-kge-shu-lcof
 * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 */
public class Min_value_in_arrays {
    public static void main(String[] args){
        int[] arr = {3,2,1};
        int[] res = getLeastNumbers(arr, 2);
        System.out.println(res);
    }

    /**
     * 快速排序后，选择最小的k个元素,分治法思想
     * @param arr
     * @param k
     * @return
     */
    public static int[] getLeastNumbers(int[] arr, int k) {
        quickSort(arr, 0, arr.length - 1);
        int[] result = new int[k];
        for(int i = 0; i < k; i ++){
            result[i] = arr[i];
        }
        return result;
    }

    private static void quickSort(int[] array, int startIndex, int endIndex){
        if(startIndex >= endIndex){
            return;
        }
        int pivotIndex = partition(array, startIndex, endIndex);
        quickSort(array, pivotIndex + 1, endIndex);
        quickSort(array, startIndex, pivotIndex - 1);
    }

    private static int partition(int[] array, int startIndex, int endIndex) {
        int pivot = array[startIndex];
        int left = startIndex;
        int right = endIndex;
        while (left != right){
            while (left < right && array[right] > pivot){
                right --;
            }
            while (left < right && array[left] <= pivot){
                left ++;
            }
            if(left < right){
                int temp = array[left];
                array[left] = array[right];
                array[right] = temp;
            }
        }
        int p = array[left];
        array[left] = pivot;
        array[startIndex] = p;
        return left;
    }
}